home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / net / mac / adsptst.c next >
Encoding:
C/C++ Source or Header  |  1997-05-20  |  9.5 KB  |  316 lines
  1. #include <AppleTalk.h>
  2. #include <ADSP.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdarg.h>
  6. #include <string.h>
  7.  
  8. int eprintf(char *form, ...)
  9. {
  10.     va_list arg;
  11.     
  12.     va_start(arg,form);
  13.     vfprintf(stderr,form,arg);
  14.     va_end(arg);
  15.     
  16.     exit(0);
  17.  
  18.     return 0;
  19. }
  20.  
  21. #define assert(x,y) ((x)? 0 : eprintf("Line %d: %s, error\n",__LINE__, y))
  22. #define macerr(x,y) ((x)? eprintf("Line %d: %s, error %d\n",__LINE__, y, x) : 0)
  23.  
  24. unsigned char *pstrcpy(unsigned char *d, unsigned char *s)
  25. {
  26.     unsigned int i = (unsigned char)s[0];
  27.  
  28.     BlockMove(s,d,i+1);
  29.     
  30.     return d;
  31. }
  32.  
  33. #define    qSize    600    // queue space
  34.  
  35. unsigned char    *dspSendQPtr;
  36. unsigned char    *dspRecvQPtr;
  37. unsigned char    *dspAttnBufPtr;
  38. unsigned char    *myData2ReadPtr;
  39. unsigned char    *myData2WritePtr;
  40. unsigned char    *myAttnMsgPtr;
  41.  
  42. DSPPBPtr    myDSPPBPtr;
  43. MPPPBPtr    myMPPPBPtr;
  44.  
  45. short    drvrRefNum;
  46. short    mppRef;
  47. short    connRefNum;
  48.  
  49. Boolean    gReceivedAnEvent;
  50. TRCCB    gDspCCB;
  51.  
  52. void DoWrite(char *buff, short size)
  53. {
  54.     // the connection with the chosen socket is open, so now send to
  55.     //  the send queue exactly myDataSize number of bytes
  56.  
  57.     // set up dspWrite parameters
  58.  
  59.     fprintf(stderr,"Writing Data\n");
  60.     
  61.     myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  62.     myDSPPBPtr->csCode = dspWrite;
  63.     myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  64.     myDSPPBPtr->u.ioParams.reqCount = size;
  65.                             // write this numberof bytes
  66.     myDSPPBPtr->u.ioParams.dataPtr = buff;    // pointer to
  67.                                         // send queue
  68.     myDSPPBPtr->u.ioParams.eom = 1;    // 1 means last byte is logical
  69.                                 // end-of-message
  70.     myDSPPBPtr->u.ioParams.flush = 1;    // 1 means send data now
  71.  
  72.     macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Write error");
  73.                                 // send data to the remote connection
  74. }
  75.  
  76. void DoRead(char *buff, short size)
  77. {
  78.     // Now read from the receive queue exactly myDataSize number of bytes.
  79.  
  80.     fprintf(stderr,"Reading Data\n");
  81.     
  82.     // set up dspRead parameters
  83.     myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  84.     myDSPPBPtr->csCode = dspRead;
  85.     myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  86.     myDSPPBPtr->u.ioParams.reqCount = size;
  87.                                 // read this number of bytes
  88.     myDSPPBPtr->u.ioParams.dataPtr = (Ptr)buff;    // pointer to
  89.                                         // read buffer
  90.  
  91.     macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "read error");
  92.                             // read data from the remote  connection
  93. }
  94.  
  95. int PickSocket(AddrBlock *addr)
  96. {
  97.     EntityName    entity;
  98.     char Buff[105];
  99.  
  100.     NBPSetEntity((Ptr) &entity, "\p=", "\pAbuseServer", "\p*");
  101.     
  102.     myMPPPBPtr->NBPinterval = 7;// retransmit every 7*8=56 ticks
  103.     myMPPPBPtr->NBPcount = 3;    // and retry 3 times
  104.     myMPPPBPtr->NBPentityPtr = (Ptr) &entity;
  105.     myMPPPBPtr->NBPretBuffPtr = (Ptr) Buff;
  106.     myMPPPBPtr->NBPretBuffSize = sizeof(Buff);
  107.     myMPPPBPtr->NBPmaxToGet = 1;
  108.  
  109.     macerr(PLookupName(myMPPPBPtr,0), "Lookup error");
  110.         
  111.     macerr(NBPExtract((Ptr)Buff,myMPPPBPtr->NBPnumGotten,1,&entity,addr),"Extraction error");
  112.  
  113.     for (int i=0; i<entity.objStr[0]; i++)
  114.         Buff[i] = entity.objStr[1+i];
  115.     Buff[entity.objStr[0]] = 0;
  116.     
  117.     fprintf(stderr,"Found [%s]\n",Buff);
  118.  
  119.     return (myMPPPBPtr->NBPnumGotten == 1);
  120. }
  121.  
  122. void main ()
  123. {
  124.     NamesTableEntry    myNTEName;
  125.     AddrBlock    myAddrBlk;
  126.     short    myAttnCode;
  127.     Byte    tempFlag;
  128.     short    tempCFlag;
  129.  
  130.     fprintf(stderr,"Open MPP\n");
  131.     macerr(OpenDriver("\p.MPP", &mppRef), "MPP Open Error");    // open .MPP driver
  132.     fprintf(stderr,"Open DSP\n");
  133.     macerr(OpenDriver("\p.DSP", &drvrRefNum), "DSP Open Error");    // open .DSP driver
  134.  
  135.     // allocate memory for data buffers
  136.     fprintf(stderr,"Alloc structures\n");
  137.  
  138.     dspSendQPtr = (unsigned char *) NewPtr(qSize);    // ADSP use only
  139.     dspRecvQPtr = (unsigned char *) NewPtr(qSize);    // ADSP use only
  140.     dspAttnBufPtr = (unsigned char *) NewPtr(attnBufSize);// ADSP use only
  141.     myAttnMsgPtr = (unsigned char *) NewPtr(128);
  142.     myDSPPBPtr = (DSPPBPtr) NewPtr(sizeof(DSPParamBlock));
  143.     myMPPPBPtr = (MPPPBPtr) NewPtr(sizeof(MPPParamBlock));
  144.  
  145.     // set up dspInit parameters
  146.  
  147.     fprintf(stderr,"DSP init\n");
  148.  
  149.     myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  150.     myDSPPBPtr->csCode = dspInit;
  151.     myDSPPBPtr->u.initParams.ccbPtr = (TPCCB) &gDspCCB;    // ptr to CCB
  152.  
  153.     // don't handle exceptions for now
  154.     myDSPPBPtr->u.initParams.userRoutine = 0;
  155. //    myDSPPBPtr->u.initParams.userRoutine = &myConnectionEvtUserRoutine;
  156.  
  157.     myDSPPBPtr->u.initParams.sendQSize = qSize;    // size of send queue
  158.     myDSPPBPtr->u.initParams.sendQueue = dspSendQPtr;// send-queue buffer
  159.     myDSPPBPtr->u.initParams.recvQSize = qSize;    // size of receive queue
  160.     myDSPPBPtr->u.initParams.recvQueue = dspRecvQPtr;    // receive-queue
  161.                                                         //buffer
  162.     myDSPPBPtr->u.initParams.attnPtr = dspAttnBufPtr;    // receive-
  163.                                                         //attention buffer
  164.     myDSPPBPtr->u.initParams.localSocket = 0;    // let ADSP assign socket
  165.  
  166.     gReceivedAnEvent = FALSE;
  167. //    gDspCCB.myA5 = SetCurrentA5();    // save A5 for the user routine
  168.  
  169.     // establish a connection end
  170.  
  171.     macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Initialization Error");
  172.  
  173.     connRefNum = myDSPPBPtr->ccbRefNum;    // save CCB ref num for later
  174.  
  175.     short node,net;
  176.     Str255 name;
  177.     
  178.     fprintf(stderr,"Get Address...");    
  179.     macerr(GetNodeAddress(&node,&net),"Can't get node address");
  180.     sprintf((char*)&name[1],"Abuse@%d:%d:%d",net,node,myDSPPBPtr->u.initParams.localSocket);
  181.     name[0] = strlen((char*)&name[1]);
  182.  
  183.     fprintf(stderr,"I'm %s\n",&name[1]);
  184.     
  185.     NBPSetNTE((Ptr) &myNTEName, "\pA1", "\pAbuseServer", "\p*",
  186.             myDSPPBPtr->u.initParams.localSocket);
  187.             // set up NBP names table entry
  188.  
  189.     // set up PRegisterName parameters
  190.  
  191.     fprintf(stderr,"Registering Name...");
  192.  
  193.     myMPPPBPtr->NBP.interval = 7;// retransmit every 7*8=56 ticks
  194.     myMPPPBPtr->NBP.count = 3;    // and retry 3 times
  195.     myMPPPBPtr->NBP.nbpPtrs.entityPtr = (Ptr) &myNTEName;
  196.                                 // name to register
  197.     myMPPPBPtr->NBP.parm.verifyFlag = 1;    // verify this name
  198.  
  199.     if (PRegisterName(myMPPPBPtr, FALSE) == noErr)
  200.     {
  201.         fprintf(stderr,"Ok.\n");
  202.         fprintf(stderr,"Waiting for connection...");
  203.                 
  204.         // open a connection passive
  205.     
  206.         // set up dspOpen parameters
  207.     
  208.         myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  209.         myDSPPBPtr->csCode = dspOpen;
  210.         myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  211.     
  212.         myDSPPBPtr->u.openParams.filterAddress.aNet = 0;
  213.         myDSPPBPtr->u.openParams.filterAddress.aNode = 0;
  214.         myDSPPBPtr->u.openParams.filterAddress.aSocket = 0;
  215.                             // address filter, don't filter
  216.     
  217.         myDSPPBPtr->u.openParams.ocMode = ocPassive;     // open connection
  218.                                             //mode
  219.         myDSPPBPtr->u.openParams.ocInterval = 7;     // use default retry interval
  220.         myDSPPBPtr->u.openParams.ocMaximum = 3;
  221.                                         // use default retry maximum
  222.     
  223.         macerr(PBControl((ParmBlkPtr)myDSPPBPtr, FALSE), "dspOpen error");
  224.                                     // open a connection
  225.                                     
  226.         myAddrBlk = myDSPPBPtr->u.openParams.remoteAddress;
  227.         fprintf(stderr,"Found %d:%d:%d\n",myAddrBlk.aNet,myAddrBlk.aNode,myAddrBlk.aSocket);
  228.     }
  229.     else
  230.     {
  231.         fprintf(stderr,"Failed.\n");
  232.         fprintf(stderr,"Searching for connection...");
  233.                 
  234.     // set up dspOptions parameters
  235.  
  236. //    myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  237. //    myDSPPBPtr->csCode = dspOptions;
  238. //    myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  239. //    myDSPPBPtr->u.optionParams.sendBlocking = blockFact;
  240.                                 // quantum for data packet
  241. //    myDSPPBPtr->u.optionParams.badSeqMax = 0;    // use default
  242. //    myDSPPBPtr->u.optionParams.useCheckSum = 0;    // don't calculate
  243.                                                     //checksum
  244.  
  245. //    macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Set Options error");
  246.                                         // set options
  247.  
  248.         // routine using the PLookupName function to pick a socket
  249.         // that will be used to establish an open connection
  250.  
  251.         assert(PickSocket(&myAddrBlk),"Can't find socket");
  252.  
  253.         fprintf(stderr,"Found %d:%d:%d\n",myAddrBlk.aNet,myAddrBlk.aNode,myAddrBlk.aSocket);
  254.  
  255.         // open a connection with the chosen socket
  256.     
  257.         // set up dspOpen parameters
  258.  
  259.         fprintf(stderr,"Opening Socket\n");
  260.     
  261.         myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  262.         myDSPPBPtr->csCode = dspOpen;
  263.         myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  264.         myDSPPBPtr->u.openParams.remoteAddress = myAddrBlk;
  265.                         //address of remote socket from PLookupName function
  266.     
  267.         myDSPPBPtr->u.openParams.filterAddress = myAddrBlk;
  268.                             // address filter, specified socket address only
  269.     
  270.         myDSPPBPtr->u.openParams.ocMode = ocRequest;     // open connection
  271.                                             //mode
  272.         myDSPPBPtr->u.openParams.ocInterval = 0;     // use default retry interval
  273.         myDSPPBPtr->u.openParams.ocMaximum = 0;
  274.                                         // use default retry maximum
  275.     
  276.         macerr(PBControl((ParmBlkPtr)myDSPPBPtr, FALSE), "dspOpen error");
  277.                                     // open a connection
  278.     }
  279.     
  280.     char st[80];
  281.     
  282.     DoWrite("Hello, other!",14);
  283.     
  284.     DoRead(st,sizeof(st));
  285.  
  286.     fprintf(stderr,"Got [%s]\n",st);
  287.  
  288.     // we're done with the connection, so remove it
  289.  
  290.     // set up dspRemove parameters
  291.  
  292.     fprintf(stderr,"Removing Connection\n");
  293.  
  294.     myDSPPBPtr->ioCRefNum = drvrRefNum;    // ADSP driver ref num
  295.     myDSPPBPtr->csCode = dspRemove;
  296.     myDSPPBPtr->ccbRefNum = connRefNum;    // connection ref num
  297.     myDSPPBPtr->u.closeParams.abort = 0;    // don't close until everything
  298.                                     //is sent and received
  299.  
  300.     macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "remove error");
  301.                                     // close and remove the connection
  302.  
  303.     // you're done with this connection, so give back the memory
  304.     DisposPtr((Ptr) dspSendQPtr);
  305.     DisposPtr((Ptr) dspRecvQPtr);
  306.     DisposPtr((Ptr) dspAttnBufPtr);
  307.     DisposPtr((Ptr) myData2ReadPtr);
  308.     DisposPtr((Ptr) myData2WritePtr);
  309.     DisposPtr((Ptr) myAttnMsgPtr);
  310.     DisposPtr((Ptr) myDSPPBPtr);
  311.     DisposPtr((Ptr) myMPPPBPtr);
  312.  
  313.     fprintf(stderr,"Done.\n");
  314. }    // MyADSP
  315.  
  316.